Please address the comments from this code review:
## Overall Comments
- There’s duplicated media validation and S3 upload code across services; consider extracting it into a shared helper to reduce repetition and improve maintainability.
- The '@lid' JID normalization logic appears in multiple handlers; centralizing that transformation into a single utility would ensure consistency.
- The fallback path in getBase64FromMediaMessage retries the download once but lacks a retry limit or clear error propagation—consider adding a defined retry policy and proper error handling.

## Individual Comments

### Comment 1
<location> `src/api/integrations/channel/whatsapp/whatsapp.baileys.service.ts:1047` </location>
<code_context>
                   },
                 });

-                if (
-                  openAiDefaultSettings &&
-                  openAiDefaultSettings.openaiCredsId &&
</code_context>

<issue_to_address>
Logging entire received object may expose sensitive data.

Log only necessary identifiers or error details to avoid exposing sensitive information.
</issue_to_address>

### Comment 2
<location> `src/api/integrations/channel/whatsapp/whatsapp.baileys.service.ts:3511` </location>
<code_context>
+      let buffer: Buffer;
</code_context>

<issue_to_address>
Fallback download logic does not propagate errors or handle all failure scenarios.

If both download attempts fail, ensure the function returns or throws an error to prevent undefined buffer usage.
</issue_to_address>

### Comment 3
<location> `src/api/integrations/chatbot/chatwoot/services/chatwoot.service.ts:570` </location>
<code_context>
   public async createConversation(instance: InstanceDto, body: any) {
-    const isLid = body.key.remoteJid.includes('@lid') && body.key.senderPn;
-    const remoteJid = isLid ? body.key.senderPn : body.key.remoteJid;
+    const isLid = body.key.previousRemoteJid?.includes('@lid') && body.key.senderPn;
+    const remoteJid = body.key.remoteJid;
     const cacheKey = `${instance.instanceName}:createConversation-${remoteJid}`;
     const lockKey = `${instance.instanceName}:lock:createConversation-${remoteJid}`;
</code_context>

<issue_to_address>
Switching to previousRemoteJid for isLid logic may break compatibility with older message formats.

If previousRemoteJid is missing, this logic could fail. Please ensure previousRemoteJid is always set or add a fallback mechanism.
</issue_to_address>

### Comment 4
<location> `src/api/integrations/chatbot/chatwoot/services/chatwoot.service.ts:592` </location>
<code_context>
             phone_number: `+${body.key.senderPn.split('@')[0]}`,
           });
+
+          if (updateContact === null) {
+            const baseContact = await this.findContact(instance, body.key.senderPn.split('@')[0]);
+            if (baseContact) {
+              await this.mergeContacts(baseContact.id, contact.id);
+              this.logger.verbose(
+                `Merge contacts: (${baseContact.id}) ${baseContact.phone_number} and (${contact.id}) ${contact.phone_number}`,
+              );
+            }
+          }
</code_context>

<issue_to_address>
mergeContacts is called without checking for race conditions or merge conflicts.

Concurrent merges may cause data inconsistencies. Please implement locking or conflict resolution if concurrent updates are possible.

Suggested implementation:

```typescript
          if (updateContact === null) {
            const baseContact = await this.findContact(instance, body.key.senderPn.split('@')[0]);
            if (baseContact) {
              // Acquire lock before merging
              const lockAcquired = await this.acquireContactMergeLock([baseContact.id, contact.id]);
              if (!lockAcquired) {
                this.logger.warn(
                  `Could not acquire lock for merging contacts: (${baseContact.id}) and (${contact.id}). Merge skipped to avoid race condition.`
                );
                return;
              }
              try {
                await this.mergeContacts(baseContact.id, contact.id);
                this.logger.verbose(
                  `Merge contacts: (${baseContact.id}) ${baseContact.phone_number} and (${contact.id}) ${contact.phone_number}`,
                );
              } finally {
                this.releaseContactMergeLock([baseContact.id, contact.id]);
              }
            }
          }

```

```typescript

  // In-memory lock for contact merges
  private contactMergeLocks: Set<number> = new Set();

  private async acquireContactMergeLock(contactIds: number[]): Promise<boolean> {
    // Sort to avoid deadlocks
    contactIds.sort((a, b) => a - b);
    for (const id of contactIds) {
      if (this.contactMergeLocks.has(id)) {
        return false;
      }
    }
    contactIds.forEach(id => this.contactMergeLocks.add(id));
    return true;
  }

  private releaseContactMergeLock(contactIds: number[]) {
    contactIds.forEach(id => this.contactMergeLocks.delete(id));
  }

  private async mergeContacts(baseId: number, mergeId: number) {
    try {
      const contact = await chatwootRequest(this.getClientCwConfig(), {
        method: 'POST',
        url: `/api/v1/accounts/${this.provider.accountId}/actions/contact_merge`,
        body: {
          base_contact_id: baseId,
          mergee_contact_id: mergeId,

```
</issue_to_address>

### Comment 5
<location> `src/api/integrations/chatbot/chatwoot/services/chatwoot.service.ts:2138` </location>
<code_context>
+            w: 320,
+            h: 180,
+          });
+          const processedBuffer = await img.getBuffer(JimpMime.png);

           const fileStream = new Readable();
</code_context>

<issue_to_address>
JimpMime.png may not be defined if JimpMime is not imported or initialized.

Please import and initialize JimpMime before using it here to prevent runtime errors. Also, confirm compatibility with previous usage of Jimp.MIME_PNG.
</issue_to_address>